home *** CD-ROM | disk | FTP | other *** search
/ Champak 138 / Volume 138 Aug 19 2011 - Damaged.iso / Games / mom_mania.swf / scripts / mx / flash / UIMovieClip.as
Text File  |  2011-08-19  |  24KB  |  861 lines
  1. package mx.flash
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.DisplayObjectContainer;
  5.    import flash.display.MovieClip;
  6.    import flash.display.Sprite;
  7.    import flash.events.Event;
  8.    import flash.geom.Rectangle;
  9.    import flash.system.ApplicationDomain;
  10.    import mx.core.IDeferredInstantiationUIComponent;
  11.    import mx.core.IFlexDisplayObject;
  12.    import mx.core.IInvalidating;
  13.    import mx.core.IStateClient;
  14.    import mx.core.IUIComponent;
  15.    import mx.core.UIComponentDescriptor;
  16.    import mx.core.mx_internal;
  17.    import mx.events.FlexEvent;
  18.    import mx.events.MoveEvent;
  19.    import mx.events.ResizeEvent;
  20.    import mx.events.StateChangeEvent;
  21.    import mx.managers.ISystemManager;
  22.    import mx.managers.IToolTipManagerClient;
  23.    
  24.    public class UIMovieClip extends MovieClip implements IDeferredInstantiationUIComponent, IToolTipManagerClient, IStateClient
  25.    {
  26.        
  27.       
  28.       private var oldHeight:Number;
  29.       
  30.       protected var _height:Number;
  31.       
  32.       private var _currentState:String;
  33.       
  34.       private var _isPopUp:Boolean = false;
  35.       
  36.       private var _systemManager:ISystemManager;
  37.       
  38.       private var explicitSizeChanged:Boolean = false;
  39.       
  40.       private var _explicitHeight:Number;
  41.       
  42.       private var _toolTip:String;
  43.       
  44.       private var _document:Object;
  45.       
  46.       public var boundingBoxName:String = "boundingBox";
  47.       
  48.       private var _measuredWidth:Number;
  49.       
  50.       private var _tweeningProperties:Array;
  51.       
  52.       protected var _width:Number;
  53.       
  54.       private var _focusPane:Sprite;
  55.       
  56.       private var transitionEndState:String;
  57.       
  58.       private var _percentWidth:Number;
  59.       
  60.       private var stateMap:Object;
  61.       
  62.       private var _descriptor:UIComponentDescriptor;
  63.       
  64.       private var oldY:Number;
  65.       
  66.       private var oldX:Number;
  67.       
  68.       private var validateMeasuredSizeFlag:Boolean = true;
  69.       
  70.       private var _includeInLayout:Boolean = true;
  71.       
  72.       private var _explicitMinWidth:Number;
  73.       
  74.       private var _explicitMaxHeight:Number;
  75.       
  76.       private var _explicitMaxWidth:Number;
  77.       
  78.       private var transitionStartFrame:Number;
  79.       
  80.       private var _measuredMinHeight:Number = 0;
  81.       
  82.       private var _measuredHeight:Number;
  83.       
  84.       private var transitionDirection:Number = 0;
  85.       
  86.       private var _owner:DisplayObjectContainer;
  87.       
  88.       private var _id:String;
  89.       
  90.       private var _parent:DisplayObjectContainer;
  91.       
  92.       private var transitionEndFrame:Number;
  93.       
  94.       private var _percentHeight:Number;
  95.       
  96.       private var _explicitMinHeight:Number;
  97.       
  98.       private var _measuredMinWidth:Number = 0;
  99.       
  100.       private var oldWidth:Number;
  101.       
  102.       private var _explicitWidth:Number;
  103.       
  104.       public function UIMovieClip()
  105.       {
  106.          validateMeasuredSizeFlag = true;
  107.          transitionDirection = 0;
  108.          explicitSizeChanged = false;
  109.          boundingBoxName = "boundingBox";
  110.          _includeInLayout = true;
  111.          _isPopUp = false;
  112.          _measuredMinHeight = 0;
  113.          _measuredMinWidth = 0;
  114.          super();
  115.          addEventListener(Event.ENTER_FRAME,enterFrameHandler,false,0,true);
  116.       }
  117.       
  118.       public function getExplicitOrMeasuredHeight() : Number
  119.       {
  120.          return !!isNaN(explicitHeight) ? Number(measuredHeight) : Number(explicitHeight);
  121.       }
  122.       
  123.       private function validateMeasuredSize() : void
  124.       {
  125.          if(validateMeasuredSizeFlag)
  126.          {
  127.             validateMeasuredSizeFlag = false;
  128.             _measuredWidth = contentBounds.width;
  129.             _measuredHeight = contentBounds.height;
  130.          }
  131.       }
  132.       
  133.       public function get minHeight() : Number
  134.       {
  135.          if(!isNaN(explicitMinHeight))
  136.          {
  137.             return explicitMinHeight;
  138.          }
  139.          return measuredMinHeight;
  140.       }
  141.       
  142.       public function set explicitMaxWidth(param1:Number) : void
  143.       {
  144.          _explicitMaxWidth = param1;
  145.       }
  146.       
  147.       protected function enterFrameHandler(param1:Event) : void
  148.       {
  149.          var _loc2_:Rectangle = null;
  150.          var _loc3_:Number = NaN;
  151.          if(explicitSizeChanged)
  152.          {
  153.             explicitSizeChanged = false;
  154.             setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  155.          }
  156.          if(isNaN(oldX))
  157.          {
  158.             oldX = x;
  159.          }
  160.          if(isNaN(oldY))
  161.          {
  162.             oldY = y;
  163.          }
  164.          if(x != oldX || y != oldY)
  165.          {
  166.             dispatchMoveEvent();
  167.          }
  168.          _loc2_ = contentBounds;
  169.          if(isNaN(oldWidth))
  170.          {
  171.             oldWidth = _width = _loc2_.width;
  172.          }
  173.          if(isNaN(oldHeight))
  174.          {
  175.             oldHeight = _height = _loc2_.height;
  176.          }
  177.          if(sizeChanged(_loc2_.width,oldWidth) || sizeChanged(_loc2_.height,oldHeight))
  178.          {
  179.             _width = _loc2_.width;
  180.             _height = _loc2_.height;
  181.             validateMeasuredSizeFlag = true;
  182.             notifySizeChanged();
  183.             dispatchResizeEvent();
  184.          }
  185.          else if(sizeChanged(width,oldWidth) || sizeChanged(height,oldHeight))
  186.          {
  187.             dispatchResizeEvent();
  188.          }
  189.          if(currentLabel && currentLabel.indexOf(":") < 0 && currentLabel != _currentState)
  190.          {
  191.             _currentState = currentLabel;
  192.          }
  193.          if(transitionDirection != 0)
  194.          {
  195.             _loc3_ = currentFrame + transitionDirection;
  196.             if(transitionDirection > 0 && _loc3_ >= transitionEndFrame || transitionDirection < 0 && _loc3_ <= transitionEndFrame)
  197.             {
  198.                gotoAndStop(stateMap[transitionEndState].frame);
  199.                transitionDirection = 0;
  200.             }
  201.             else
  202.             {
  203.                gotoAndStop(_loc3_);
  204.             }
  205.          }
  206.       }
  207.       
  208.       public function get tweeningProperties() : Array
  209.       {
  210.          return _tweeningProperties;
  211.       }
  212.       
  213.       public function set minHeight(param1:Number) : void
  214.       {
  215.          explicitMinHeight = param1;
  216.       }
  217.       
  218.       public function set id(param1:String) : void
  219.       {
  220.          _id = param1;
  221.       }
  222.       
  223.       public function get explicitMinHeight() : Number
  224.       {
  225.          return _explicitMinHeight;
  226.       }
  227.       
  228.       override public function set height(param1:Number) : void
  229.       {
  230.          explicitHeight = param1;
  231.       }
  232.       
  233.       public function set tweeningProperties(param1:Array) : void
  234.       {
  235.          _tweeningProperties = param1;
  236.       }
  237.       
  238.       public function get focusPane() : Sprite
  239.       {
  240.          return _focusPane;
  241.       }
  242.       
  243.       protected function notifySizeChanged() : void
  244.       {
  245.          if(parent && parent is IInvalidating)
  246.          {
  247.             IInvalidating(parent).invalidateSize();
  248.             IInvalidating(parent).invalidateDisplayList();
  249.          }
  250.       }
  251.       
  252.       public function set document(param1:Object) : void
  253.       {
  254.          _document = param1;
  255.       }
  256.       
  257.       public function getExplicitOrMeasuredWidth() : Number
  258.       {
  259.          return !!isNaN(explicitWidth) ? Number(measuredWidth) : Number(explicitWidth);
  260.       }
  261.       
  262.       public function get explicitHeight() : Number
  263.       {
  264.          return _explicitHeight;
  265.       }
  266.       
  267.       public function get percentWidth() : Number
  268.       {
  269.          return _percentWidth;
  270.       }
  271.       
  272.       public function get minWidth() : Number
  273.       {
  274.          if(!isNaN(explicitMinWidth))
  275.          {
  276.             return explicitMinWidth;
  277.          }
  278.          return measuredMinWidth;
  279.       }
  280.       
  281.       public function get baselinePosition() : Number
  282.       {
  283.          return 0;
  284.       }
  285.       
  286.       public function get systemManager() : ISystemManager
  287.       {
  288.          var _loc1_:DisplayObject = null;
  289.          var _loc2_:DisplayObjectContainer = null;
  290.          var _loc3_:IUIComponent = null;
  291.          if(!_systemManager)
  292.          {
  293.             _loc1_ = root;
  294.             if(_loc1_)
  295.             {
  296.                _systemManager = _loc1_ as ISystemManager;
  297.             }
  298.             else
  299.             {
  300.                _loc2_ = parent;
  301.                while(_loc2_)
  302.                {
  303.                   _loc3_ = _loc2_ as IUIComponent;
  304.                   if(_loc3_)
  305.                   {
  306.                      _systemManager = _loc3_.systemManager;
  307.                      break;
  308.                   }
  309.                   _loc2_ = _loc2_.parent;
  310.                }
  311.             }
  312.          }
  313.          return _systemManager;
  314.       }
  315.       
  316.       public function get currentState() : String
  317.       {
  318.          return _currentState;
  319.       }
  320.       
  321.       public function set explicitMinHeight(param1:Number) : void
  322.       {
  323.          _explicitMinHeight = param1;
  324.          notifySizeChanged();
  325.       }
  326.       
  327.       override public function get parent() : DisplayObjectContainer
  328.       {
  329.          return !!_parent ? _parent : super.parent;
  330.       }
  331.       
  332.       public function get measuredWidth() : Number
  333.       {
  334.          validateMeasuredSize();
  335.          return _measuredWidth;
  336.       }
  337.       
  338.       public function get owner() : DisplayObjectContainer
  339.       {
  340.          return _owner;
  341.       }
  342.       
  343.       protected function get contentBounds() : Rectangle
  344.       {
  345.          if(boundingBoxName && boundingBoxName != "" && boundingBoxName in this)
  346.          {
  347.             return this[boundingBoxName].getBounds(this);
  348.          }
  349.          return getBounds(this);
  350.       }
  351.       
  352.       public function get maxWidth() : Number
  353.       {
  354.          return !!isNaN(explicitMaxWidth) ? Number(10000) : Number(explicitMaxWidth);
  355.       }
  356.       
  357.       public function parentChanged(param1:DisplayObjectContainer) : void
  358.       {
  359.          if(!param1)
  360.          {
  361.             _parent = null;
  362.          }
  363.          else if(param1 is IUIComponent || param1 is ISystemManager)
  364.          {
  365.             _parent = param1;
  366.          }
  367.          else
  368.          {
  369.             _parent = param1.parent;
  370.          }
  371.       }
  372.       
  373.       public function set focusPane(param1:Sprite) : void
  374.       {
  375.          _focusPane = param1;
  376.       }
  377.       
  378.       public function set descriptor(param1:UIComponentDescriptor) : void
  379.       {
  380.          _descriptor = param1;
  381.       }
  382.       
  383.       public function registerEffects(param1:Array) : void
  384.       {
  385.       }
  386.       
  387.       public function get explicitMinWidth() : Number
  388.       {
  389.          return _explicitMinWidth;
  390.       }
  391.       
  392.       override public function set visible(param1:Boolean) : void
  393.       {
  394.          setVisible(param1);
  395.       }
  396.       
  397.       public function set includeInLayout(param1:Boolean) : void
  398.       {
  399.          _includeInLayout = param1;
  400.       }
  401.       
  402.       public function set explicitHeight(param1:Number) : void
  403.       {
  404.          _explicitHeight = param1;
  405.          explicitSizeChanged = true;
  406.          notifySizeChanged();
  407.       }
  408.       
  409.       public function set percentWidth(param1:Number) : void
  410.       {
  411.          _percentWidth = param1;
  412.          notifySizeChanged();
  413.       }
  414.       
  415.       public function get id() : String
  416.       {
  417.          return _id;
  418.       }
  419.       
  420.       public function set systemManager(param1:ISystemManager) : void
  421.       {
  422.          _systemManager = param1;
  423.       }
  424.       
  425.       public function executeBindings(param1:Boolean = false) : void
  426.       {
  427.          var _loc2_:Object = null;
  428.          var _loc3_:* = undefined;
  429.          _loc2_ = descriptor && descriptor.document ? descriptor.document : parentDocument;
  430.          _loc3_ = ApplicationDomain.currentDomain.getDefinition("mx.binding.BindingManager");
  431.          if(_loc3_ != null)
  432.          {
  433.             _loc3_.executeBindings(_loc2_,id,this);
  434.          }
  435.       }
  436.       
  437.       override public function get height() : Number
  438.       {
  439.          if(!isNaN(_height))
  440.          {
  441.             return _height;
  442.          }
  443.          return super.height;
  444.       }
  445.       
  446.       public function set minWidth(param1:Number) : void
  447.       {
  448.          explicitMinWidth = param1;
  449.       }
  450.       
  451.       public function set currentState(param1:String) : void
  452.       {
  453.          var _loc2_:* = null;
  454.          var _loc3_:Number = NaN;
  455.          var _loc4_:Number = NaN;
  456.          var _loc5_:StateChangeEvent = null;
  457.          if(param1 == _currentState)
  458.          {
  459.             return;
  460.          }
  461.          if(!stateMap)
  462.          {
  463.             buildStateMap();
  464.          }
  465.          if(stateMap[param1])
  466.          {
  467.             _loc2_ = _currentState + "-" + param1 + ":start";
  468.             if(stateMap[_loc2_])
  469.             {
  470.                _loc3_ = stateMap[_loc2_].frame;
  471.                _loc4_ = stateMap[_currentState + "-" + param1 + ":end"].frame;
  472.             }
  473.             if(isNaN(_loc3_))
  474.             {
  475.                _loc2_ = param1 + "-" + _currentState + ":end";
  476.                if(stateMap[_loc2_])
  477.                {
  478.                   _loc3_ = stateMap[_loc2_].frame;
  479.                   _loc4_ = stateMap[param1 + "-" + _currentState + ":start"].frame;
  480.                }
  481.             }
  482.             if(isNaN(_loc3_))
  483.             {
  484.                _loc2_ = "*-" + param1 + ":start";
  485.                if(stateMap[_loc2_])
  486.                {
  487.                   _loc3_ = stateMap[_loc2_].frame;
  488.                   _loc4_ = stateMap["*-" + param1 + ":end"].frame;
  489.                }
  490.             }
  491.             if(isNaN(_loc3_))
  492.             {
  493.                _loc2_ = param1 + "-*:end";
  494.                if(stateMap[_loc2_])
  495.                {
  496.                   _loc3_ = stateMap[_loc2_].frame;
  497.                   _loc4_ = stateMap[param1 + "-*:start"].frame;
  498.                }
  499.             }
  500.             if(isNaN(_loc3_))
  501.             {
  502.                _loc2_ = _currentState + "-*:start";
  503.                if(stateMap[_loc2_])
  504.                {
  505.                   _loc3_ = stateMap[_loc2_].frame;
  506.                   _loc4_ = stateMap[_currentState + "-*:end"].frame;
  507.                }
  508.             }
  509.             if(isNaN(_loc3_))
  510.             {
  511.                _loc2_ = "*-" + _currentState + ":end";
  512.                if(stateMap[_loc2_])
  513.                {
  514.                   _loc3_ = stateMap[_loc2_].frame;
  515.                   _loc4_ = stateMap["*-" + _currentState + ":start"].frame;
  516.                }
  517.             }
  518.             if(isNaN(_loc3_))
  519.             {
  520.                _loc2_ = "*-*:start";
  521.                if(stateMap[_loc2_])
  522.                {
  523.                   _loc3_ = stateMap[_loc2_].frame;
  524.                   _loc4_ = stateMap["*-*:end"].frame;
  525.                }
  526.             }
  527.             if(isNaN(_loc3_) && param1 in stateMap)
  528.             {
  529.                _loc3_ = stateMap[param1].frame;
  530.             }
  531.             if(isNaN(_loc3_))
  532.             {
  533.                return;
  534.             }
  535.             (_loc5_ = new StateChangeEvent(StateChangeEvent.CURRENT_STATE_CHANGING)).oldState = _currentState;
  536.             _loc5_.newState = param1;
  537.             dispatchEvent(_loc5_);
  538.             if(isNaN(_loc4_))
  539.             {
  540.                gotoAndStop(_loc3_);
  541.                transitionDirection = 0;
  542.             }
  543.             else
  544.             {
  545.                if(currentFrame < Math.min(_loc3_,_loc4_) || currentFrame > Math.max(_loc3_,_loc4_))
  546.                {
  547.                   gotoAndStop(_loc3_);
  548.                }
  549.                else
  550.                {
  551.                   _loc3_ = currentFrame;
  552.                }
  553.                transitionStartFrame = _loc3_;
  554.                transitionEndFrame = _loc4_;
  555.                transitionDirection = _loc4_ > _loc3_ ? Number(1) : Number(-1);
  556.                transitionEndState = param1;
  557.             }
  558.             (_loc5_ = new StateChangeEvent(StateChangeEvent.CURRENT_STATE_CHANGE)).oldState = _currentState;
  559.             _loc5_.newState = param1;
  560.             dispatchEvent(_loc5_);
  561.             _currentState = param1;
  562.          }
  563.       }
  564.       
  565.       public function get document() : Object
  566.       {
  567.          return _document;
  568.       }
  569.       
  570.       public function get explicitMaxWidth() : Number
  571.       {
  572.          return _explicitMaxWidth;
  573.       }
  574.       
  575.       public function set measuredMinWidth(param1:Number) : void
  576.       {
  577.          _measuredMinWidth = param1;
  578.       }
  579.       
  580.       public function set cacheHeuristic(param1:Boolean) : void
  581.       {
  582.       }
  583.       
  584.       public function set maxHeight(param1:Number) : void
  585.       {
  586.          explicitMaxHeight = param1;
  587.       }
  588.       
  589.       public function setActualSize(param1:Number, param2:Number) : void
  590.       {
  591.          if(sizeChanged(_width,param1) || sizeChanged(_height,param2))
  592.          {
  593.             dispatchResizeEvent();
  594.          }
  595.          _width = param1;
  596.          _height = param2;
  597.          super.scaleX = param1 / measuredWidth;
  598.          super.scaleY = param2 / measuredHeight;
  599.       }
  600.       
  601.       public function get cachePolicy() : String
  602.       {
  603.          return "";
  604.       }
  605.       
  606.       public function set owner(param1:DisplayObjectContainer) : void
  607.       {
  608.          _owner = param1;
  609.       }
  610.       
  611.       public function get descriptor() : UIComponentDescriptor
  612.       {
  613.          return _descriptor;
  614.       }
  615.       
  616.       public function get includeInLayout() : Boolean
  617.       {
  618.          return _includeInLayout;
  619.       }
  620.       
  621.       public function createReferenceOnParentDocument(param1:IFlexDisplayObject) : void
  622.       {
  623.          if(id && id != "")
  624.          {
  625.             param1[id] = this;
  626.          }
  627.       }
  628.       
  629.       public function get measuredMinWidth() : Number
  630.       {
  631.          return _measuredMinWidth;
  632.       }
  633.       
  634.       private function sizeChanged(param1:Number, param2:Number) : Boolean
  635.       {
  636.          return Math.abs(param1 - param2) > 1;
  637.       }
  638.       
  639.       public function set isPopUp(param1:Boolean) : void
  640.       {
  641.          _isPopUp = param1;
  642.       }
  643.       
  644.       public function initialize() : void
  645.       {
  646.          dispatchEvent(new FlexEvent(FlexEvent.PREINITIALIZE));
  647.          if(boundingBoxName && boundingBoxName != "" && boundingBoxName in this)
  648.          {
  649.             this[boundingBoxName].visible = false;
  650.          }
  651.          if(explicitSizeChanged)
  652.          {
  653.             explicitSizeChanged = false;
  654.             setActualSize(getExplicitOrMeasuredWidth(),getExplicitOrMeasuredHeight());
  655.          }
  656.          dispatchEvent(new FlexEvent(FlexEvent.INITIALIZE));
  657.       }
  658.       
  659.       override public function set width(param1:Number) : void
  660.       {
  661.          explicitWidth = param1;
  662.       }
  663.       
  664.       public function set percentHeight(param1:Number) : void
  665.       {
  666.          _percentHeight = param1;
  667.          notifySizeChanged();
  668.       }
  669.       
  670.       public function set maxWidth(param1:Number) : void
  671.       {
  672.          explicitMaxWidth = param1;
  673.       }
  674.       
  675.       private function buildStateMap() : void
  676.       {
  677.          var _loc1_:Array = null;
  678.          var _loc2_:int = 0;
  679.          _loc1_ = currentLabels;
  680.          stateMap = {};
  681.          _loc2_ = 0;
  682.          while(_loc2_ < _loc1_.length)
  683.          {
  684.             stateMap[_loc1_[_loc2_].name] = _loc1_[_loc2_];
  685.             _loc2_++;
  686.          }
  687.       }
  688.       
  689.       public function deleteReferenceOnParentDocument(param1:IFlexDisplayObject) : void
  690.       {
  691.          if(id && id != "")
  692.          {
  693.             param1[id] = null;
  694.          }
  695.       }
  696.       
  697.       public function owns(param1:DisplayObject) : Boolean
  698.       {
  699.          while(param1 && param1 != this)
  700.          {
  701.             if(param1 is IUIComponent)
  702.             {
  703.                param1 = IUIComponent(param1).owner;
  704.             }
  705.             else
  706.             {
  707.                param1 = param1.parent;
  708.             }
  709.          }
  710.          return param1 == this;
  711.       }
  712.       
  713.       public function get measuredHeight() : Number
  714.       {
  715.          validateMeasuredSize();
  716.          return _measuredHeight;
  717.       }
  718.       
  719.       public function setVisible(param1:Boolean, param2:Boolean = false) : void
  720.       {
  721.          super.visible = param1;
  722.          if(!param2)
  723.          {
  724.             dispatchEvent(new FlexEvent(!!param1 ? FlexEvent.SHOW : FlexEvent.HIDE));
  725.          }
  726.       }
  727.       
  728.       public function get maxHeight() : Number
  729.       {
  730.          return !!isNaN(explicitMaxHeight) ? Number(10000) : Number(explicitMaxHeight);
  731.       }
  732.       
  733.       public function set explicitMaxHeight(param1:Number) : void
  734.       {
  735.          _explicitMaxHeight = param1;
  736.          notifySizeChanged();
  737.       }
  738.       
  739.       private function dispatchResizeEvent() : void
  740.       {
  741.          var _loc1_:ResizeEvent = null;
  742.          _loc1_ = new ResizeEvent(ResizeEvent.RESIZE);
  743.          _loc1_.oldWidth = oldWidth;
  744.          _loc1_.oldHeight = oldHeight;
  745.          dispatchEvent(_loc1_);
  746.          oldWidth = width;
  747.          oldHeight = height;
  748.       }
  749.       
  750.       override public function get width() : Number
  751.       {
  752.          if(!isNaN(_width))
  753.          {
  754.             return _width;
  755.          }
  756.          return super.width;
  757.       }
  758.       
  759.       public function get percentHeight() : Number
  760.       {
  761.          return _percentHeight;
  762.       }
  763.       
  764.       public function set explicitMinWidth(param1:Number) : void
  765.       {
  766.          _explicitMinWidth = param1;
  767.          notifySizeChanged();
  768.       }
  769.       
  770.       public function get isPopUp() : Boolean
  771.       {
  772.          return _isPopUp;
  773.       }
  774.       
  775.       public function get explicitMaxHeight() : Number
  776.       {
  777.          return _explicitMaxHeight;
  778.       }
  779.       
  780.       public function move(param1:Number, param2:Number) : void
  781.       {
  782.          this.x = param1;
  783.          this.y = param2;
  784.          if(param1 != oldX || param2 != oldY)
  785.          {
  786.             dispatchMoveEvent();
  787.          }
  788.       }
  789.       
  790.       public function get toolTip() : String
  791.       {
  792.          return _toolTip;
  793.       }
  794.       
  795.       public function set explicitWidth(param1:Number) : void
  796.       {
  797.          _explicitWidth = param1;
  798.          explicitSizeChanged = true;
  799.          notifySizeChanged();
  800.       }
  801.       
  802.       public function get parentDocument() : Object
  803.       {
  804.          var _loc1_:IUIComponent = null;
  805.          var _loc2_:ISystemManager = null;
  806.          if(document == this)
  807.          {
  808.             _loc1_ = parent as IUIComponent;
  809.             if(_loc1_)
  810.             {
  811.                return _loc1_.document;
  812.             }
  813.             _loc2_ = parent as ISystemManager;
  814.             if(_loc2_)
  815.             {
  816.                return _loc2_.document;
  817.             }
  818.             return null;
  819.          }
  820.          return document;
  821.       }
  822.       
  823.       public function set toolTip(param1:String) : void
  824.       {
  825.          var _loc2_:* = undefined;
  826.          _loc2_ = ApplicationDomain.currentDomain.getDefinition("mx.managers.ToolTipManager");
  827.          if(_loc2_)
  828.          {
  829.             _loc2_.mx_internal::registerToolTip(this,param1);
  830.          }
  831.          _toolTip = param1;
  832.       }
  833.       
  834.       private function dispatchMoveEvent() : void
  835.       {
  836.          var _loc1_:MoveEvent = null;
  837.          _loc1_ = new MoveEvent(MoveEvent.MOVE);
  838.          _loc1_.oldX = oldX;
  839.          _loc1_.oldY = oldY;
  840.          dispatchEvent(_loc1_);
  841.          oldX = x;
  842.          oldY = y;
  843.       }
  844.       
  845.       public function get explicitWidth() : Number
  846.       {
  847.          return _explicitWidth;
  848.       }
  849.       
  850.       public function get measuredMinHeight() : Number
  851.       {
  852.          return _measuredMinHeight;
  853.       }
  854.       
  855.       public function set measuredMinHeight(param1:Number) : void
  856.       {
  857.          _measuredMinHeight = param1;
  858.       }
  859.    }
  860. }
  861.